home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / net_src.arc / vfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-08  |  2.6 KB  |  149 lines
  1. /*
  2.  * Routines for implementing RAM-based virtual files.
  3.  * Written for Mark Williams stdio library.
  4.  *   -- Howard Chu  03:15, 12-07-88
  5.  */
  6.  
  7. #include <stdio.h>
  8.  
  9. #define    MEMSIZ    (16*1024)
  10. #define    _FMEM    0x40        /* For stdio flags... */
  11.  
  12. typedef    struct    vfile {
  13.     char buf[MEMSIZ];
  14.     short cnt;
  15.     struct vfile *next;
  16. }    vfile;
  17.  
  18. int    vgetc(),vputc();
  19. static void vfree();
  20.  
  21. FILE *tmpfile()
  22. {
  23.     register FILE *newbuf;
  24.     vfile *ptr;
  25.  
  26.     newbuf=(FILE *)malloc(sizeof(struct FILE)+sizeof(struct vfile));
  27.  
  28.     if(newbuf != NULL) {
  29.         ptr = (vfile *)((long)newbuf + sizeof(struct FILE));
  30.         ptr->next = NULL;
  31.     /*
  32.      * We'll use _cp as current pointer, _bp as buffer end, and
  33.      * _dp as buffer beginning... _cc is number of bytes in this
  34.      * block.
  35.      */
  36.         newbuf->_cp=newbuf->_dp=newbuf->_bp=(char *)ptr;
  37.         newbuf->_cc=0;
  38.         newbuf->_gt=vgetc;
  39.         newbuf->_pt=vputc;
  40.         newbuf->_ff=(_FMEM | _FINUSE | _FSTBUF);
  41.                     /* Mem, in use, user buffer */
  42.         newbuf->_uc=0;
  43.         newbuf->_fd=0xff;
  44.     }
  45.     return newbuf;
  46. }
  47.  
  48. int
  49. vseek(fp, where, how)
  50. register FILE *fp;
  51. long where;
  52. int how;
  53. {
  54.     vfile *ptr;
  55.  
  56.     if(fp->_ff & _FMEM) {
  57.  
  58.         ptr=(vfile *)(fp->_dp);
  59.         ptr->cnt = fp->_cc;
  60.  
  61.         switch(how) {
  62.         case 0: ptr=(vfile *)((long)fp+sizeof(struct FILE));
  63.             while(where > MEMSIZ) {
  64.                 ptr = ptr->next;
  65.                 where -= MEMSIZ;
  66.             }
  67.             fp->_cp = fp->_dp = fp->_bp = (char *)ptr;
  68.             fp->_cp += where;
  69.             if(ptr)
  70.                 fp->_bp += ptr->cnt;
  71.             break;
  72.         default:    return (-1);        /* Too lazy... */
  73.         }
  74.         return 0;
  75.     } else return fseek(fp, where, how);
  76. }
  77.     
  78. int
  79. vclose(fp)
  80. register FILE *fp;
  81. {
  82.     vfile *ptr;
  83.  
  84.     if(fp->_ff & _FMEM) {
  85.         ptr=(vfile *)(fp->_dp);
  86.         vfree(ptr->next);
  87.         free(fp);
  88.         return 0;
  89.     } else    return(fclose(fp));
  90. }
  91.  
  92. static void
  93. vfree(ptr)
  94. register vfile *ptr;
  95. {
  96.     if(ptr) {
  97.         vfree(ptr->next);
  98.         free(ptr);
  99.     }
  100. }
  101.  
  102. int
  103. vgetc(fp)
  104. register FILE *fp;
  105. {
  106.     register vfile *ptr;
  107.  
  108.     if(fp->_cp < fp->_bp)
  109.         return *(fp->_cp++);
  110.  
  111.     if(fp->_bp == fp->_dp)        /* No data yet. */
  112.         return EOF;
  113.  
  114.     ptr=(vfile *)(fp->_dp);
  115.     ptr = ptr->next;
  116.     if(!ptr)            /* No more blocks in chain */
  117.         return EOF;
  118.  
  119.     fp->_cp = fp->_dp = (char *)(ptr);    /* Get next block */
  120.     fp->_bp = fp->_dp + ptr->cnt;
  121.     return *(fp->_cp++);
  122. }
  123.  
  124. int
  125. vputc(c, fp)
  126. char c;
  127. register FILE *fp;
  128. {
  129.     vfile *ptr;
  130.  
  131.     if(fp->_cc < MEMSIZ) {
  132.         *(fp->_cp++) = c;
  133.         fp->_cc++;
  134.         return c;
  135.     }
  136.  
  137.     ptr=(vfile *)fp->_dp;
  138.     if(!(ptr->next = (vfile *)malloc(sizeof(vfile))))
  139.         return EOF;        /* End of the line...! */
  140.  
  141.     ptr->cnt = fp->_cc;
  142.     ptr->next->next = (vfile *)0;
  143.     fp->_cc = 1;
  144.     fp->_cp = fp->_bp = fp->_dp = (char *)(ptr->next);
  145.  
  146.     *(fp->_cp++) = c;
  147.     return c;
  148. }
  149.